package com.deyang.mycommon.ui.activity.study;

import android.os.Bundle;
import android.view.View;

import com.deyang.mycommon.R;
import com.deyang.mycommon.ui.baseui.BaseActivity;
import com.deyang.mycommon.util.Logger;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import butterknife.ButterKnife;
import butterknife.OnClick;
import rx.Observable;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.observables.GroupedObservable;

/**
 * @author wangdyang
 * @createDate 2018年7月30日09:39:42
 * @desc
 */
public class RxJavaObservableConvertActivity extends BaseActivity {


    @Override
    protected void initView(Bundle savedInstanceState) {
        setContentView(R.layout.activity_rx_java_observable_convert);
        ButterKnife.bind(this);
    }

    @Override
    protected void processLogic(Bundle savedInstanceState) {
    }

    @OnClick({
            R.id.btn_buffer,
            R.id.btn_flatmap,
            R.id.btn_groupBy,
            R.id.btn_map,
    })
    @Override
    public void onClick(View v) {
        super.onClick(v);
        switch (v.getId()) {
            case R.id.btn_buffer:
                rxBuffer();
                break;
            case R.id.btn_flatmap:
                rxFlatmap();
                break;
            case R.id.btn_groupBy:
                rxGroupBy();
                break;
            case R.id.btn_map:
                rxMap();
                break;
        }
    }

    /**
     * map 将数据 通过某种格式或函数进行转换
     * 区别于flatMap： flatMap ：重新创建了一个被观察者  1对多的关系
     * map 是1对1的关系
     *
     * cast  强制转换
     */
    private void rxMap() {
        Observable.just(1, 2, 3, 4, 5)
                .map(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        return integer * 10;
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Logger.e(TAG, "rxMap : " + integer);
                    }
                });
    }

    /**
     * 根据指定格式或函数进行分组，还可进行转换  返回的分组 key为0 时 为匹配格式  key为1时为不匹配格式的
     */
    private void rxGroupBy() {
        Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
                .groupBy(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        return integer % 2;
                    }
                })
                .subscribe(new Action1<GroupedObservable<Integer, Integer>>() {
                    @Override
                    public void call(final GroupedObservable<Integer, Integer> integerIntegerGroupedObservable) {

                        //返回各个分组的值
                        integerIntegerGroupedObservable.subscribe(new Action1<Integer>() {
                            @Override
                            public void call(Integer integer) {
                                Logger.e(TAG, "groupBy ---- " + integerIntegerGroupedObservable.getKey() + " : " + integer);
                            }
                        });

                        /*
                        //分组结束后 返回各组的个数  跟上边方法不能同时调用
                        integerIntegerGroupedObservable.count().subscribe(new Action1<Integer>() {
                            @Override
                            public void call(Integer integer) {
                                Logger.e(TAG, "groupBy ---- " + integerIntegerGroupedObservable.getKey() + " : " + integer);
                            }
                        });
                        */
                    }
                });

        Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
                .groupBy(new Func1<Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer) {
                        return integer % 2;
                    }
                }, new Func1<Integer, String>() {
                    @Override
                    public String call(Integer integer) {
                        return "groupByIntegerToString : " + integer;
                    }
                })
                .subscribe(new Action1<GroupedObservable<Integer, String>>() {
                    @Override
                    public void call(final GroupedObservable<Integer, String> integerStringGroupedObservable) {
                        integerStringGroupedObservable.subscribe(new Action1<String>() {
                            @Override
                            public void call(String s) {

                                Logger.e(TAG, "groupByIntegerToString groupBy ---- " + integerStringGroupedObservable.getKey() + " : " + s);
                            }
                        });
                    }
                });
    }

    /**
     * Flatmap 可将指定的类型数据 转换为 另一种类型数据
     * flatMapIterable  大致同 Flatmap ，返回的类型是Iterable 迭代器类型，故可进行扩展
     */
    private void rxFlatmap() {
        Observable.just(1, 2, 3)
                .flatMap(new Func1<Integer, Observable<String>>() {
                    @Override
                    public Observable<String> call(Integer integer) {
                        return Observable.just("flatMap :" + integer);
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Logger.e(TAG, s);
                    }
                });

        Observable.just(1, 2, 3)
                .flatMapIterable(new Func1<Integer, Iterable<String>>() {
                    @Override
                    public Iterable<String> call(Integer integer) {
                        List<String> list = new ArrayList<>();
                        for (int i = 0; i < 3; i++) {
                            list.add("flatMapIterable:" + integer);
                        }
                        return list;
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Logger.e(TAG, s);
                    }
                });
    }

    /**
     * buffer 可进行缓存一定数量然后进行发送，还可通过 skip 进行跳过制 定 数据
     * 还可通过时间规则来缓存
     */
    private void rxBuffer() {
        Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
                .buffer(2, 3)
                .subscribe(new Action1<List<Integer>>() {
                    @Override
                    public void call(List<Integer> integers) {
                        Logger.e(TAG, "buffer: integers:" + integers);
                    }
                });

        Observable.interval(1, TimeUnit.SECONDS)
                //隔十秒发送
                .buffer(10, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<List<Long>>() {
                    @Override
                    public void call(List<Long> longs) {
                        Logger.e(TAG, "buffer: longs:" + longs);
                    }
                });
    }


}
